# coding:utf-8
import numpy as np
from numpy import nan as NA
import pandas as pd

import matplotlib.pyplot as plt
plt.rc('figure', figsize=(10, 6))  # 设置默认的figure尺寸
np.set_printoptions(
    precision=4, suppress=True)  # 设置小数位数为4，默认是8；suppress压缩科学计数法表示的浮点数

# 柯里化一个print
printn = lambda *x: print(*x, sep='\n')

# 处理缺失数据
'''
缺失数据处理函数：dropna--根据各标签的值中是否存在缺失数据对轴标签进行过滤，可通过阈值调节对缺失值的容忍度
fillna--用指定值或插值方法(ffill或bfill)填充缺失数据
isnull--返回一个含有布尔值的对象，布尔值表明那些是缺失值，该对象的类型与源类型一致
notnull--isnull的否定式
'''


def testNAN():
    string_data = pd.Series(['aardvark', 'artichoke', np.nan, 'avocado'])
    printn('字符串Series:', string_data)
    printn('非空判断:', string_data.isnull())

    # Python内置的None值在对象数组中也可以作为NA
    string_data[0] = None
    printn('内置的None作为NA:', string_data.isnull())

# testNAN()


# 滤除缺失数据
def testFilterNA():
    data = pd.Series([1, NA, 3.5, NA, 7])
    printn('剔除NA:', data.dropna())

    # 布尔索引等价
    printn('使用bool值剔除na:', data[data.notnull()])

    # 对于DataFrame对象，事情就有点复杂了。你可能希望丢弃全NA或含有NA的⾏或列。dropna默认丢弃任何含有缺失值的⾏
    data = pd.DataFrame(
        [[1., 6.5, 3.], [1., NA, NA], [NA, NA, NA], [NA, 6.5, 3.]])
    cleaned = data.dropna()
    printn('原DataFrame', data)
    printn("丢弃NA行后:", cleaned)
    # 传⼊how='all'将只丢弃全为NA的那些⾏：
    printn("丢弃全为NA的那些⾏:", data.dropna(how='all'))
    # 丢弃全为Na的列，传入axis=1
    data[4] = NA
    printn('更新na的列:', data)
    printn("丢弃全为NA的那些列:", data.dropna(how='all', axis=1))

    # 假设你只想留下⼀部分观测数据，可以⽤thresh参数实现此⽬的
    df = pd.DataFrame(np.random.randn(7, 3))
    df.iloc[:4, 1] = NA
    df.iloc[:2, 2] = NA
    printn("原始dataframe:", df)
    printn("丢弃NA行后:", df.dropna())

    # thresh参数，保留提出Na值后，剩余数据不少于n的行。如thresh=2，保留剔除NA后，数据个数不少于2的行
    printn('剔除na后，数据个数不少于2的行:', df.dropna(thresh=2))
# testFilterNA()


# 填充缺失数据
# 调⽤fillna就会将缺失值替换为指定值
'''
参数：value--用于填充缺失值的标量值或字典对象；method--插值方式，默认ffill;
axis--待填充的轴，默认axis=0；inplace--修改调用者对象而不产生副本；
limit--(对于前向和后向填充)可以连续填充的最大数量
'''


def testfillna():
    df = pd.DataFrame(np.random.randn(7, 3))
    df.iloc[:4, 1] = NA
    df.iloc[:2, 2] = NA
    printn("填充0:", df.fillna(0))
    # 若是通过⼀个字典调⽤fillna，就可以实现对不同的列填充不同的值
    printn('字典填充:', df.fillna({1: 0.5, 2: 0}))
    # fillna默认会返回新对象，但也可以对现有对象进⾏就地修改
    df.fillna(0, inplace=True)
    printn("原地修改后的dataframe:", df)

    # 对reindexing有效的那些插值⽅法也可⽤于fillna
    df = pd.DataFrame(np.random.randn(6, 3))
    df.iloc[2:, 1] = NA
    df.iloc[4:, 2] = NA
    printn("原dataframe:", df)
    printn("前值填充:", df.fillna(method='ffill'))  # 用前面的值填充
    printn("前值填充(只填2次):", df.fillna(method='ffill', limit=2))

    # 也可传入平均值等
    data = pd.Series([1., NA, 3.5, NA, 7])
    printn("填充平均值:", data.fillna(data.mean()))
# testfillna()


# 数据转换
# 移除重复数据
def removedup():
    data = pd.DataFrame(
        {'k1': ['one', 'two'] * 3 + ['two'],
         'k2': [1, 1, 2, 3, 3, 4, 4]})
    printn("原数据:", data)
    # DataFrame的duplicated⽅法返回⼀个布尔型Series，表示各⾏是否是重复⾏（前⾯出现过的⾏）
    printn('重复行检测:', data.duplicated())
    # drop_duplicates()丢弃后面的重复行
    printn('丢弃重复行:', data.drop_duplicates())
    # 假设我们还有⼀列值，且只希望根据k1列过滤重复项
    data['v1'] = range(7)
    printn("过滤k1:", data.drop_duplicates(['k1']))
    # duplicated和drop_duplicates默认保留的是第⼀个出现的值组合。传⼊keep='last'则保留最后⼀个
    printn('设置保留重复行最后一个:', data.drop_duplicates(['k1', 'k2'], keep='last'))
# removedup()


# 利用函数或映射进行数据转换
# 使⽤map是⼀种实现元素级转换以及其他数据清理⼯作的便捷⽅式。
def testtransform():
    data = pd.DataFrame(
        {
            'food': [
                'bacon', 'pulled pork', 'bacon', 'Pastrami', 'corned beef',
                'Bacon', 'pastrami', 'honey ham', 'nova lox'
            ],
            'ounces': [4, 3, 12, 6, 7.5, 8, 3, 5, 6]
        })
    printn("原数据:", data)
    # 添加⼀列表示该⾁类⻝物来源的动物类型。我们先编写⼀个不同⾁类到动物的映射
    meat_to_animal = {
        'bacon': 'pig',
        'pulled pork': 'pig',
        'pastrami': 'cow',
        'corned beef': 'cow',
        'honey ham': 'pig',
        'nova lox': 'salmon'
    }
    # 使⽤Series的str.lower⽅法，将⾁类的⾸字⺟转换为⼩写,否则会有meat_to_animal大小写匹配问题
    lowercased = data['food'].str.lower()
    printn("首字母小写:", lowercased)
    # Series的map⽅法可以接受⼀个函数或含有映射关系的字典型对象
    data['animal'] = lowercased.map(meat_to_animal)
    printn('添加animal列:', data)

    # 我们也可以传⼊⼀个能够完成全部这些⼯作的函数
    s = data['food'].map(lambda x: meat_to_animal[x.lower()])
    printn('food列:', s)
# testtransform()


# 替换值
'''
利⽤fillna⽅法填充缺失数据可以看做值替换的⼀种特殊情况。前⾯已经看到，map可⽤于修改对象的
数据⼦集，⽽replace则提供了⼀种实现该功能的更简单、更灵活的⽅式
注意：data.replace⽅法与data.str.replace不同，后者做的是字符串的元素级替换。我们会在后
⾯学习Series的字符串⽅法。
'''


def testreplace():
    data = pd.Series([1., -999., 2., -999., -1000., 3.])
    printn("原数据:", data)

    # 我们可以利⽤replace来产⽣⼀个新的Series（除⾮传⼊inplace=True）
    s = data.replace(-999, np.nan)
    printn('替换为na后:', s)
    # 如果希望⼀次性替换多个值，可以传⼊⼀个由待替换值组成的列表以及⼀个替换值：
    s2 = data.replace([-999, -1000], np.nan)
    printn("多值替换:", s2)
    # 要让每个值有不同的替换值，可以传递⼀个替换列表：
    s3 = data.replace([-999, -1000], [np.nan, 0])
    printn("多值替换多值:", s3)
    # 传⼊的参数也可以是字典
    s4 = data.replace({-999: np.nan, -1000: 0})
    printn("字典替换:", s4)
# testreplace()


# 重命名轴索引--map和rename方法
'''
跟Series中的值⼀样，轴标签也可以通过函数或映射进⾏转换，从⽽得到⼀个新的不同标签的对象。
轴还可以被就地修改，⽽⽆需新建⼀个数据结构
'''


def testaxisname():
    data = pd.DataFrame(
        np.arange(12).reshape((3, 4)),
        index=['Ohio', 'Colorado', 'New York'],
        columns=['one', 'two', 'three', 'four'])
    printn("原数据:", data)
    # 跟Series⼀样，轴索引也有⼀个map⽅法
    transform = lambda x: x[:4].upper()
    s = data.index.map(transform)
    printn('轴索引的map方法:', s)

    # 可以将其赋值给index，这样就可以对DataFrame进⾏就地修改
    data.index = data.index.map(transform)
    printn('就地更改index:', data)
    # 如果想要创建数据集的转换版（⽽不是修改原始数据），⽐较实⽤的⽅法是rename
    # title方法就是首字母大写
    s2 = data.rename(index=str.title, columns=str.upper)
    printn('index和columns直接rename:', s2)
    # rename可以结合字典型对象实现对部分轴标签的更新
    s3 = data.rename(index={'OHIO': 'INDIANA'}, columns={'three': 'peekaboo'})
    printn('字典更新轴标签:', s3)
    # rename可以实现复制DataFrame并对其索引和列标签进⾏赋值。如果希望就地修改某个数据集，传⼊inplace=True即可
    data.rename(index={'OHIO': 'INDIANA'}, inplace=True)
    printn("inplace原地修改:", data)
# testaxisname()


# 离散化和面元分析
# 为了便于分析，连续数据常常被离散化或拆分为“⾯元”（bin）。假设有⼀组⼈员数据，⽽你希望将它们划分为不同的年龄组
def testDiscretization():
    ages = [20, 22, 25, 27, 21, 23, 37, 31, 61, 45, 41, 32]
    # 将这些数据划分为“18到25”、“26到35”、“35到60”以及“60以上”⼏个⾯元。需要使⽤pandas的cut函数
    bins = [18, 25, 35, 60, 100]
    cats = pd.cut(ages, bins)
    # 返回的是⼀个特殊的Categorical对象。结果展示了pandas.cut划分的⾯元。你可以将其看做⼀组表示⾯元名称的字符串。它的底层含有⼀个表示不同分类名称的类型数组，以及⼀个codes属性中的年龄数据的标签
    printn("面元:", cats)
    printn("codes:", cats.codes)
    printn("categories:", cats.categories)
    # pd.value_counts(cats)是pandas.cut结果的⾯元计数。
    printn('各年龄段计数:', pd.value_counts(cats))

    # 跟“区间”的数学符号⼀样，圆括号表示开端，⽽⽅括号则表示闭端（包括）。哪边是闭端可以通过right=False进⾏修改
    s = pd.cut(ages, [18, 26, 36, 61, 100], right=False)
    printn("左闭:", s)

    # 可以通过传递⼀个列表或数组到labels，设置⾃⼰的⾯元名称
    group_names = ['Youth', 'YoungAdult', 'MiddleAged', 'Senior']
    s2 = pd.cut(ages, bins, labels=group_names)
    printn("面元名称:", s2)

    # 向cut传⼊的是⾯元的数量⽽不是确切的⾯元边界，则它会根据数据的最⼩值和最⼤值计算等⻓⾯元
    # 将⼀些均匀分布的数据分成指定组数
    data = np.random.rand(20)
    s3 = pd.cut(data, 4, precision=2)  # 选项precision=2，限定⼩数只有两位
    printn("面元数量方式:", s3)
    '''
    qcut是⼀个⾮常类似于cut的函数，它可以根据样本分位数对数据进⾏⾯元划分。根据数据的分布情
    况，cut可能⽆法使各个⾯元中含有相同数量的数据点。⽽qcut由于使⽤的是样本分位数，因此可以得
    到⼤⼩基本相等的⾯元
    '''
    data = np.random.randn(1000)  # Normally distributed
    cats = pd.qcut(data, 4)  # Cut into quartiles
    printn("qcut方法:", cats)
    printn("qcut方法统计:", pd.value_counts(cats))

    # 与cut类似，你也可以传递⾃定义的分位数（0到1之间的数值，包含端点）
    s4 = pd.qcut(data, [0, 0.1, 0.5, 0.9, 1.])
    printn("⾃定义的分位数:", s4)
# testDiscretization()


# 检测和过滤异常值
# 过滤或变换异常值（outlier）在很⼤程度上就是运⽤数组运算
def testcheck():
    data = pd.DataFrame(np.random.randn(1000, 4))
    printn('data的描述:', data.describe())
    # 假设你想要找出某列中绝对值⼤⼩超过3的值：
    col = data[2]
    printn("第2列大于3的值:", col[np.abs(col) > 3])
    # 要选出全部含有“超过3或－3的值”的⾏，你可以在布尔型DataFrame中使⽤any⽅法
    s = data[(np.abs(data) > 3).any(1)]
    printn("全部含有“超过3或－3的值”的⾏:", s)

    # 根据这些条件，就可以对值进⾏设置。下⾯的代码可以将值限制在区间－3到3以内
    # 根据数据的值是正还是负，np.sign(data)可以⽣成1和-1
    data[np.abs(data) > 3] = np.sign(data) * 3
    printn('修改后的data描述:', data.describe())
    printn('np.sign的前5行:', np.sign(data).head())
# testcheck()


# 排列和随机采样
'''
利⽤numpy.random.permutation函数可以轻松实现对Series或DataFrame的列的排列⼯作
（permuting，随机重排序）。通过需要排列的轴的⻓度调⽤permutation，可产⽣⼀个表示新顺序的整
数数组
'''


def testpermute():
    df = pd.DataFrame(np.arange(5 * 4).reshape((5, 4)))
    printn("原数据:", df)
    sampler = np.random.permutation(5)
    printn('轴长5的排列:', sampler)
    # 然后就可以在基于iloc的索引操作或take函数中使⽤该数组了
    df1 = df.take(sampler)
    printn("重排后:", df1)

    # 如果不想⽤替换的⽅式选取随机⼦集，可以在Series和DataFrame上使⽤sample⽅法
    printn("sample方法:", df.sample(n=3))
    # 要通过替换的⽅式产⽣样本（允许重复选择），可以传递replace=True到sample
    choices = pd.Series([5, 7, -1, 6, 4])
    draws = choices.sample(n=10, replace=True)
    printn("sample方法replace=True:", draws)
# testpermute()


# 计算指标/哑变量
def testIndicator():
    # 如果DataFrame的某⼀列中含有k个不同的值，则可以派⽣出⼀个k列矩阵或DataFrame（其值全为1和0）
    # pandas有⼀个get_dummies函数可以实现该功能
    df = pd.DataFrame(
        {'key': ['b', 'b', 'a', 'c', 'a', 'b'],
         'data1': range(6)})
    printn('根据key派生同秩的只有01的DataFrame:', pd.get_dummies(df['key']))
    # 想给指标DataFrame的列加上⼀个前缀，以便能够跟其他数据进⾏合并。get_dummies的prefix参数可以实现该功能
    dummies = pd.get_dummies(df['key'], prefix='key')
    df_with_dummy = df[['data1']].join(dummies)
    printn('加前缀的指标与原df合并:', df_with_dummy)
    # 如果DataFrame中的某⾏同属于多个分类。看⼀下MovieLens    1M数据集
    mnames = ['movie_id', 'title', 'genres']
    movies = pd.read_table(
        'datasets/movielens/movies.dat',
        sep='::',
        header=None,
        names=mnames,
        engine='python')
    printn("前10条数据:", movies[:10])
    # 要为每个genre添加指标变量就需要做⼀些数据规整操作。⾸先，我们从数据集中抽取出不同的genre值
    all_genres = []
    for x in movies.genres:
        all_genres.extend(x.split('|'))
    genres = pd.unique(all_genres)  # 去重
    printn("所有的genres:", genres)
    # 构建指标DataFrame的⽅法之⼀是从⼀个全零DataFrame开始
    zero_matrix = np.zeros((len(movies), len(genres)))
    dummies = pd.DataFrame(zero_matrix, columns=genres)
    # 现在，迭代每⼀部电影，并将dummies各⾏的条⽬设为1。要这么做，我们使⽤dummies.columns来计算每个类型的列索引
    gen = movies.genres[0]
    printn("分割gen:", gen.split('|'))
    sindex = dummies.columns.get_indexer(gen.split('|'))
    printn('列索引为:', sindex)
    # 然后，根据索引，使⽤.iloc设定值
    for i, gen in enumerate(movies.genres):
        indices = dummies.columns.get_indexer(gen.split('|'))
        dummies.iloc[i, indices] = 1
    # 然后，和以前⼀样，再将其与movies合并起来
    movies_windic = movies.join(dummies.add_prefix('Genre_'))
    printn("movies_windic首位:", movies_windic.iloc[0])

    # 对于很⼤的数据，⽤这种⽅式构建多成员指标变量就会变得⾮常慢。最好使⽤更低级的函数，将其写⼊NumPy数组，然后结果包装在DataFrame中。
    # ⼀个对统计应⽤有⽤的秘诀是：结合get_dummies和诸如cut之类的离散化函数。⽤numpy.random.seed，使这个例⼦具有确定性
    np.random.seed(12345)
    values = np.random.rand(10)
    printn('随机的ndarray:', values)
    bins = [0, 0.2, 0.4, 0.6, 0.8, 1]
    s = pd.get_dummies(pd.cut(values, bins))
    printn('根据cut求的的指标:', s)
# testIndicator()


# 字符串操作
# 字符串对象方法
'''
字符串方法：count--返回子串在字符串中出现次数；endswith、startswith--如果字符串以某个后缀结尾(前缀开头)，则返回True
join--将字符串用作连接其他字符串序列的分隔符；index--返回子串第一个字符所在位置，找不到引发ValueError
find--返回子串第一个字符所在位置，找不到返回-1；rfind--返回最后一个发现的子串第一个字符所在位置，找不到返回-1
replace--用另一个字符串替换指定子串；strip、rstrip、lstrip--去除空白符(包括换行符)
split--通过指定的分隔符将字符串拆分成一组子串；lower、upper--分别将字母字符转换为小写或大写
ljust、rjust--用空格(或其他字符)填充字符串的空白侧以返回复合最低宽度的字符串。
'''


def testStringObj():
    val = 'a,b,  guido'
    s1 = val.split(',')
    printn("分割逗号:", s1)
    # split常常与strip⼀起使⽤，以去除空⽩符（包括换⾏符）
    pieces = [x.strip() for x in val.split(',')]
    printn("去除空格分割:", pieces)

    # 利⽤加法，可以将这些⼦字符串以双冒号分隔符的形式连接起来
    first, second, third = pieces
    s2 = first + '::' + second + '::' + third
    printn("双冒号连接:", s2)
    # 但这种⽅式并不是很实⽤。⼀种更快更符合Python⻛格的⽅式是，向字符串"::"的join⽅法传⼊⼀个列表或元组
    s3 = '::'.join(pieces)
    printn("python风格连接:", s3)

    # 其它⽅法关注的是⼦串定位。检测⼦串的最佳⽅式是利⽤Python的in关键字，还可以使⽤index和find
    s4 = 'guido' in val
    s5 = val.index(',')
    s6 = val.find(':')
    print("检测字串:", s4, s5, s6)
    # ind和index的区别：如果找不到字符串，index将会引发⼀个异常（⽽不是返回－1）
    try:
        val.index(':')
    except ValueError as e:
        print("index找不到的错误信息:", e)
    # 与此相关，count可以返回指定⼦串的出现次数
    s7 = val.count(',')
    print("子串次数:", s7)
    # replace⽤于将指定模式替换为另⼀个模式。通过传⼊空字符串，它也常常⽤于删除模式
    s8 = val.replace(',', '::')
    s9 = val.replace(',', '')
    printn("替换或删除:", s8, s9)
# testStringObj()


# 正则表达式
'''
findall、finditer--返回字符串中所有的非重叠匹配模式。findall返回列表，finditer通过迭代器逐个返回;
match--从起始位置匹配，匹配到返回一个匹配项，否则返回None
search--任意位置开始匹配，找到则返回一个匹配项
split--根据找到的模式将字符串拆分为数段
sub、subn--将字符串中的所有(sub)或前n个(subn)模式替换为指定的表达式。在替换字符串中可以通过\1、\2等符号表示各分组相
'''


def testRegex():
    # 假设我想要拆分⼀个字符串，分隔符为数量不定的⼀组空⽩符（制表符、空格、换⾏符等）。描述⼀个或多个空⽩符的regex是\s+
    import re
    text = "foo    bar\t baz  \tqux"
    s = re.split('\\s+', text)
    print("空白符分割后:", s)
    # 调⽤re.split('\s+',text)时，正则表达式会先被编译，然后再在text上调⽤其split⽅法。
    # 可以⽤re.compile⾃⼰编译regex以得到⼀个可重⽤的regex对象
    # 如果打算对许多字符串应⽤同⼀条正则表达式，强烈建议通过re.compile创建regex对象。这样将可以节省⼤量的CPU时间
    regex = re.compile('\\s+')
    s2 = regex.split(text)  # 使用正则对象regx去执行方法
    printn("编译后分割:", s2)
    # 希望得到匹配regex的所有模式，则可以使⽤findall⽅法
    s3 = regex.findall(text)
    printn("find方法:", s3)
    # ：如果想避免正则表达式中不需要的转义（\），则可以使⽤原始字符串字⾯量如r'C:\x'（也可以编写其等价式'C:\x'）
    '''
    match和search跟findall功能类似。findall返回的是字符串中所有的匹配项，⽽search则只返回第⼀个
    匹配项。match更加严格，它只匹配字符串的⾸部。
    '''
    # 假设我们有⼀段⽂本以及⼀条能够识别⼤部分电⼦邮件地址的正则表达式
    text = """Dave dave@google.com
        Steve steve@gmail.com
        Rob rob@gmail.com
        Ryan ryan@yahoo.com
        """
    pattern = r'[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}'

    # re.IGNORECASE makes the regex case-insensitive
    regex = re.compile(pattern, flags=re.IGNORECASE)  # 忽略大小写
    # 对text使⽤findall将得到⼀组电⼦邮件地址：
    s4 = regex.findall(text)
    printn("所有电子邮件:", s4)
    # search返回的是⽂本中第⼀个电⼦邮件地址（以特殊的匹配项对象形式返回）。对于上⾯那个regex，匹配项对象只能告诉我们模式在原字符串中的起始和结束位置
    m = regex.search(text)
    printn("search的结果:", m)
    # 另一种获取方法
    printn("另一种获取方法:", text[m.start():m.end()])
    # regex.match则将返回None，因为它只匹配出现在字符串开头的模式：
    printn("match的结果:", regex.match(text))
    # 相关的，sub⽅法可以将匹配到的模式替换为指定字符串，并返回所得到的新字符串
    printn("sub的结果:", regex.sub('REDACTED', text))

    # 假设你不仅想要找出电⼦邮件地址，还想将各个地址分成3个部分：⽤户名、域名以及域后缀。要实现此功能，只需将待分段的模式的各部分⽤圆括号包起来即可
    pattern = r'([A-Z0-9._%+-]+)@([A-Z0-9.-]+)\.([A-Z]{2,4})'
    regex = re.compile(pattern, flags=re.IGNORECASE)
    # 由这种修改过的正则表达式所产⽣的匹配项对象，可以通过其groups⽅法返回⼀个由模式各段组成的元组
    m = regex.match('wesm@bright.net')
    printn("groups方法获取:", m.groups())
    # 对于带有分组功能的模式，findall会返回⼀个元组列表
    s5 = regex.findall(text)
    printn("findall返回的元组列表:", s5)
    # sub还能通过诸如\1、\2之类的特殊符号访问各匹配项中的分组。符号\1对应第⼀个匹配的组，\2对应第⼆个匹配的组，以此类推
    print(regex.sub(r'Username: \1, Domain: \2, Suffix: \3', text))
# testRegex()


# pandas的矢量化字符串函数
'''
更多pandas的字符串操作：cat--实现元素级的字符串连接操作，可指定分隔符；
count--返回表示各字符串是否含有指定模式的布尔型数组；
extract--使用带分组的正则表达式从字符串Sereis提取一个或多个字符串，结果式一个DataFrame，每组一列
endswith、startswith--是否后缀、前缀
findall--计算个字符串的模式列表；get--获取个元素的第i个字符
isalnum--str.alnum;isalpha--str.isalpha;isdecimal--str.isdecimal;isdigit--str.isdigit;islower--str.islower;
isnumeric--str.isnumeric;isupper--str.isupper
join--根据指定的分隔符将Series中各元素的字符串连接起来
len--计算各字符串的长度；lower、power--转换大小写
match--根据指定的正则表达式对各个元素执行re.match，返回匹配的组为列表
pad--在字符串的左边、右边或两边添加空白符;center--想当于pad(side='both')
repeat--重复值。例如s.str.repeat(3)相当于对各个字符串执行x*3
replace--用指定字符串替换找到的模式；slice--对Series中的各个字符串进行子串截取
split--根据分隔符或整个表达式对字符串进行拆分
strip--去除两边的空白符，包括新行；rstrip--去除右边空白符；lstrip--去除左边空白符
'''


def testVectorized():
    # 含有字符串的列有时还含有缺失数据
    data = {
        'Dave': 'dave@google.com',
        'Steve': 'steve@gmail.com',
        'Rob': 'rob@gmail.com',
        'Wes': np.nan
    }
    data = pd.Series(data)
    printn("原数据:", data)
    printn("非空判断:", data.isnull())
    '''
    通过data.map，所有字符串和正则表达式⽅法都能被应⽤于（传⼊lambda表达式或其他函数）各个值，但是如果存在NA（null）就会报错
    。为了解决这个问题，Series有⼀些能够跳过NA值的⾯向数组⽅法，进⾏字符串操作。通过Series的str属性即可访问这些⽅法。
    '''
    # 我们可以通过str.contains检查各个电⼦邮件地址是否含有"gmail"
    printn("检查是否含有:", data.str.contains('gmail'))
    # 也可以使⽤正则表达式，还可以加上任意re选项（如IGNORECASE）
    import re
    pattern = r'([A-Z0-9._%+-]+)@([A-Z0-9.-]+)\.([A-Z]{2,4})'
    printn("检查是否含有:", data.str.findall(pattern, flags=re.IGNORECASE))
    matches = data.str.match(pattern, flags=re.IGNORECASE)
    printn("match匹配:", matches)
    # 有两个办法可以实现⽮量化的元素获取操作：要么使⽤str.get，要么在str属性上使⽤索引，要访问嵌⼊列表中的元素，
    # 我们可以传递索引到这两个函数中
    s = data.str.get(1)
    printn("元素1:", s)
    s2 = data.str[0]
    printn("元素2:", s2)

    # 你可以利⽤这种⽅法对字符串进⾏截取：
    s3 = data.str[:5]
    printn("截取字符串:", s3)


testVectorized()
